JavaScript BigInt Kriptografi Kurva Eliptik: Pendalaman Operasi Tingkat Lanjut

Di era yang didominasi oleh interaksi digital, dari keuangan terdesentralisasi (DeFi) hingga pesan terenkripsi ujung-ke-ujung, kekuatan fondasi kriptografi kita tidak pernah sepenting ini. Kriptografi Kurva Eliptik (ECC) berdiri sebagai pilar kriptografi kunci publik modern, menawarkan keamanan yang kuat dengan ukuran kunci yang lebih kecil dibandingkan dengan pendahulunya seperti RSA. Selama bertahun-tahun, melakukan operasi matematika yang kompleks ini secara langsung di JavaScript merupakan sebuah tantangan, seringkali membutuhkan pustaka khusus yang mengabstraksi detail tingkat rendah atau menangani keterbatasan tipe angka standar JavaScript.

Pengenalan tipe BigInt asli di JavaScript (ES2020) adalah momen revolusioner. Ini membebaskan pengembang dari batasan tipe Number floating-point 64-bit, menyediakan mekanisme untuk menangani bilangan bulat arbitrer besar. Fitur tunggal ini membuka potensi untuk implementasi kriptografi yang berkinerja, asli, dan lebih transparan secara langsung di dalam lingkungan JavaScript seperti browser dan Node.js.

Meskipun banyak pengembang yang familiar dengan dasar-dasar ECC—menghasilkan pasangan kunci dan menandatangani pesan—kekuatan sebenarnya dari teknologi ini terletak pada operasi yang lebih canggih. Artikel ini bergerak melampaui fundamental untuk menjelajahi protokol dan teknik kriptografi canggih yang sekarang dapat diakses berkat BigInt. Kita akan mempelajari Elliptic Curve Diffie-Hellman (ECDH) untuk pertukaran kunci yang aman, pemulihan kunci publik dari tanda tangan, dan tanda tangan Schnorr yang kuat dan ramah agregat.

Revolusi BigInt dalam Kriptografi JavaScript

Sebelum kita menyelami operasi tingkat lanjut, penting untuk memahami mengapa BigInt menjadi pengubah permainan untuk kriptografi di JavaScript.

Masalah dengan Tipe `Number`

Tipe Number tradisional JavaScript adalah angka floating-point 64-bit presisi ganda IEEE 754. Format ini sangat bagus untuk berbagai aplikasi tetapi memiliki keterbatasan penting untuk kriptografi: ia hanya dapat merepresentasikan bilangan bulat dengan aman hingga Number.MAX_SAFE_INTEGER, yaitu 2⁵³ - 1.

Kunci kriptografi dan nilai antara dalam ECC jauh lebih besar. Misalnya, kurva secp256k1 populer yang digunakan oleh Bitcoin dan Ethereum beroperasi pada bidang bilangan prima yang panjangnya 256 bit. Angka-angka ini lebih besar dari yang dapat ditangani oleh tipe Number standar tanpa kehilangan presisi. Mencoba melakukan perhitungan dengan angka-angka seperti itu akan menghasilkan hasil yang salah dan tidak aman.

Masukkan `BigInt`: Bilangan Bulat Presisi Arbitrer

BigInt memecahkan masalah ini dengan elegan. Ini adalah tipe numerik yang berbeda yang menyediakan cara untuk merepresentasikan bilangan bulat dengan ukuran berapa pun. Anda dapat membuat BigInt dengan menambahkan `n` ke akhir literal integer atau dengan memanggil konstruktor BigInt().

Contoh:

const aLargeNumber = 9007199254740991n; // Aman dengan BigInt
const anEvenLargerNumber = 115792089237316195423570985008687907853269984665640564039457584007908834671663n; // Bilangan prima 256-bit

Dengan BigInt, semua operator aritmatika standar (+, -, *, /, %, **) berfungsi seperti yang diharapkan pada bilangan bulat besar ini. Kemampuan ini adalah landasan tempat implementasi ECC JavaScript asli dibangun, memungkinkan komputasi algoritma kriptografi secara langsung, tepat, dan aman tanpa bergantung pada modul WebAssembly eksternal atau pustaka angka multi-bagian yang rumit.

Penyegaran tentang Fundamental Kriptografi Kurva Eliptik

Untuk menghargai operasi tingkat lanjut, mari kita tinjau secara singkat konsep inti ECC.

Intinya, ECC didasarkan pada struktur aljabar kurva eliptik di atas bidang terbatas. Kurva-kurva ini didefinisikan oleh persamaan Weierstrass:

y² = x³ + ax + b (mod p)

Di mana `a` dan `b` adalah konstanta yang menentukan bentuk kurva, dan `p` adalah bilangan prima besar yang mendefinisikan bidang terbatas.

Konsep Kunci

• Titik pada Kurva: Sepasang koordinat (x, y) yang memenuhi persamaan kurva. Semua operasi kriptografi kita pada dasarnya adalah "aritmatika titik".
• Titik Dasar (G): Titik awal terstandarisasi yang diketahui publik pada kurva.
• Kunci Privat (d): Bilangan bulat acak yang sangat besar dan aman secara kriptografi. Ini adalah rahasia Anda. Dalam konteks BigInt, `d` adalah `BigInt` besar.
• Kunci Publik (Q): Titik pada kurva yang berasal dari kunci privat dan titik dasar melalui operasi yang disebut perkalian skalar: Q = d * G. Ini berarti menambahkan titik G ke dirinya sendiri `d` kali.

Keamanan ECC bergantung pada Masalah Logaritma Diskrit Kurva Eliptik (ECDLP). Sangat mudah secara komputasi untuk menghitung kunci publik `Q` dengan kunci privat `d` dan titik dasar `G`. Namun, secara komputasi tidak mungkin untuk menentukan kunci privat `d` hanya dengan kunci publik `Q` dan titik dasar `G`.

Operasi Tingkat Lanjut 1: Pertukaran Kunci Elliptic Curve Diffie-Hellman (ECDH)

Salah satu aplikasi ECC yang paling kuat adalah membangun rahasia bersama antara dua pihak melalui saluran komunikasi yang tidak aman. Ini dicapai menggunakan protokol pertukaran kunci Elliptic Curve Diffie-Hellman (ECDH).

Tujuannya

Bayangkan dua individu, Alice dan Bob, yang ingin berkomunikasi dengan aman. Mereka perlu menyetujui kunci enkripsi simetris yang hanya mereka ketahui, tetapi satu-satunya cara komunikasi mereka adalah saluran publik yang dapat dipantau oleh penyadap, Eve. ECDH memungkinkan mereka untuk menghitung rahasia bersama yang identik tanpa pernah mengirimkannya secara langsung.

Protokol Langkah demi Langkah

1. Pembuatan Kunci:
   • Alice menghasilkan kunci privatnya, `d_A` (BigInt acak besar), dan kunci publik yang sesuai, `Q_A = d_A * G`.
   • Bob menghasilkan kunci privatnya, `d_B` (BigInt acak besar lainnya), dan kunci publiknya, `Q_B = d_B * G`.
2. Pertukaran Kunci Publik:
   • Alice mengirimkan kunci publiknya, `Q_A`, ke Bob.
   • Bob mengirimkan kunci publiknya, `Q_B`, ke Alice.
   • Eve, si penyadap, dapat melihat `Q_A` dan `Q_B`, tetapi tidak dapat memperoleh kunci privat `d_A` atau `d_B` karena ECDLP.
3. Perhitungan Rahasia Bersama:
   • Alice mengambil kunci publik Bob `Q_B` dan mengalikannya dengan kunci privatnya sendiri `d_A` untuk mendapatkan titik S: S = d_A * Q_B.
   • Bob mengambil kunci publik Alice `Q_A` dan mengalikannya dengan kunci privatnya sendiri `d_B` untuk mendapatkan titik S: S = d_B * Q_A.

Keajaiban Komutativitas

Baik Alice maupun Bob sampai pada titik rahasia yang sama persis `S` pada kurva. Ini karena perkalian skalar bersifat asosiatif dan komutatif:

Perhitungan Alice: S = d_A * Q_B = d_A * (d_B * G)

Perhitungan Bob: S = d_B * Q_A = d_B * (d_A * G)

Karena d_A * d_B * G = d_B * d_A * G, mereka berdua menghitung hasil yang sama tanpa mengungkapkan kunci privat mereka.

Dari Titik Bersama ke Kunci Simetris

Rahasia bersama yang dihasilkan `S` adalah titik pada kurva, bukan kunci simetris yang cocok untuk algoritma enkripsi seperti AES. Untuk memperoleh kunci, praktik standar adalah mengambil koordinat x dari titik `S` dan meneruskannya melalui Fungsi Derivasi Kunci (KDF), seperti HKDF (Fungsi Derivasi Kunci Berbasis HMAC). KDF mengambil rahasia bersama dan opsional garam dan info lainnya, dan menghasilkan kunci yang kuat secara kriptografi dengan panjang yang diinginkan.

Semua perhitungan yang mendasari—menghasilkan kunci privat sebagai `BigInt` acak dan melakukan perkalian skalar—sangat bergantung pada aritmatika `BigInt`.

Operasi Tingkat Lanjut 2: Pemulihan Kunci Publik dari Tanda Tangan

Di banyak sistem, terutama blockchain, efisiensi dan minimalisasi data sangat penting. Biasanya, untuk memverifikasi tanda tangan, Anda memerlukan pesan, tanda tangan itu sendiri, dan kunci publik penanda tangan. Namun, properti cerdas dari Elliptic Curve Digital Signature Algorithm (ECDSA) memungkinkan Anda untuk memulihkan kunci publik langsung dari pesan dan tanda tangan. Ini berarti kunci publik tidak perlu dikirimkan, menghemat ruang yang berharga.

Bagaimana Cara Kerjanya (Tingkat Tinggi)

Tanda tangan ECDSA terdiri dari dua komponen, (`r`, `s`).

• `r` diturunkan dari koordinat x dari titik acak `k * G`.
• `s` dihitung berdasarkan hash pesan (`z`), kunci privat (`d`), dan `r`. Formulanya adalah: `s = k_inverse * (z + r * d) mod n`, di mana `n` adalah urutan kurva.

Melalui manipulasi aljabar dari persamaan verifikasi tanda tangan, dimungkinkan untuk memperoleh ekspresi untuk kunci publik `Q`. Namun, proses ini menghasilkan dua kemungkinan kunci publik yang valid. Untuk menyelesaikan ambiguitas ini, sepotong kecil informasi tambahan yang disebut ID pemulihan (sering dilambangkan sebagai `v` atau `recid`) disertakan dengan tanda tangan. ID ini, biasanya 0, 1, 2, atau 3, menentukan solusi mana yang benar dan apakah koordinat y kunci genap atau ganjil.

Mengapa `BigInt` Penting

Operasi matematika yang diperlukan untuk pemulihan kunci publik sangat intensif dan melibatkan invers modular, perkalian, dan penambahan angka 256-bit. Misalnya, langkah kunci melibatkan perhitungan `(r_inverse * (s*k - z)) * G`. Operasi-operasi inilah yang dirancang untuk `BigInt`. Tanpa itu, melakukan perhitungan ini di JavaScript asli tidak mungkin tanpa kehilangan presisi dan keamanan yang signifikan.

Aplikasi Praktis: Transaksi Ethereum

Teknik ini terkenal digunakan di Ethereum. Transaksi yang ditandatangani tidak berisi alamat publik pengirim secara langsung. Sebaliknya, alamat (yang diturunkan dari kunci publik) dipulihkan dari komponen `v`, `r`, dan `s` dari tanda tangan. Pilihan desain ini menghemat 20 byte pada setiap transaksi, penghematan yang signifikan pada skala blockchain global.

Operasi Tingkat Lanjut 3: Tanda Tangan Schnorr dan Agregasi

Meskipun ECDSA banyak digunakan, ia memiliki kelemahan tertentu, termasuk malleabilitas tanda tangan dan kurangnya properti agregasi. Tanda tangan Schnorr, skema berbasis ECC lainnya, memberikan solusi elegan untuk masalah-masalah ini dan dianggap oleh banyak ahli kriptografi lebih unggul.

Keunggulan Utama Tanda Tangan Schnorr

• Keamanan yang Dapat Dibuktikan: Mereka memiliki bukti keamanan yang lebih lugas dan kuat dibandingkan dengan ECDSA.
• Non-Malleabilitas: Tidak mungkin pihak ketiga mengubah tanda tangan yang valid menjadi tanda tangan valid lainnya untuk pesan dan kunci yang sama.
• Linearitas (Kekuatan Super): Ini adalah keuntungan yang paling signifikan. Tanda tangan Schnorr bersifat linear, yang memungkinkan teknik agregasi yang kuat.

Agregasi Tanda Tangan Dijelaskan

Properti linearitas berarti bahwa beberapa tanda tangan dari beberapa penanda tangan dapat digabungkan menjadi satu tanda tangan yang ringkas. Ini adalah pengubah permainan untuk skema multi-tanda tangan (multisig).

Pertimbangkan skenario di mana transaksi memerlukan tanda tangan dari 3 dari 5 peserta. Dengan ECDSA, Anda perlu menyertakan ketiga tanda tangan individual pada blockchain, memakan ruang yang signifikan.

Dengan tanda tangan Schnorr, prosesnya jauh lebih efisien:

1. Agregasi Kunci: 3 peserta dapat menggabungkan kunci publik individual mereka (`Q1`, `Q2`, `Q3`) untuk membuat satu kunci publik agregat (`Q_agg`).
2. Agregasi Tanda Tangan: Melalui protokol kolaboratif seperti MuSig2, para peserta dapat membuat satu tanda tangan agregat (`S_agg`) yang valid untuk kunci publik agregat `Q_agg`.

Hasilnya adalah transaksi yang terlihat identik dengan transaksi penanda tangan tunggal standar di bagian luar. Ia memiliki satu kunci publik dan satu tanda tangan. Ini secara dramatis meningkatkan efisiensi, skalabilitas, dan privasi, karena pengaturan multisig yang kompleks menjadi tidak dapat dibedakan dari yang sederhana.

Peran `BigInt`

Keajaiban agregasi berakar pada penambahan titik kurva eliptik sederhana dan aritmatika skalar. Membuat kunci agregat melibatkan `Q_agg = Q1 + Q2 + Q3`, dan membuat tanda tangan agregat melibatkan penambahan komponen tanda tangan individual modulo urutan kurva. Semua operasi ini—yang membentuk dasar protokol seperti MuSig2—dilakukan pada bilangan bulat besar dan koordinat kurva, menjadikan `BigInt` alat yang sangat diperlukan untuk mengimplementasikan tanda tangan Schnorr dan skema agregasi di JavaScript.

Pertimbangan Implementasi dan Praktik Terbaik Keamanan

Meskipun `BigInt` memberdayakan kita untuk memahami dan mengimplementasikan operasi tingkat lanjut ini, membangun kriptografi tingkat produksi adalah tugas yang berbahaya. Berikut adalah beberapa pertimbangan penting.

1. JANGAN Membuat Kripto Sendiri untuk Produksi

Artikel ini bertujuan untuk mendidik dan mengilustrasikan mekanisme yang mendasari. Anda tidak boleh mengimplementasikan primitif kriptografi ini dari awal untuk aplikasi produksi. Gunakan pustaka yang diperiksa dengan baik, diaudit, dan ditinjau sejawat seperti `noble-curves`. Pustaka ini dibuat khusus oleh para ahli dan memperhitungkan banyak masalah keamanan yang halus tetapi kritis.

2. Operasi Waktu Konstan dan Serangan Saluran Samping

Salah satu jebakan paling berbahaya adalah serangan saluran samping. Penyerang dapat menganalisis aspek non-fungsional dari suatu sistem—seperti konsumsi daya atau waktu yang tepat yang dibutuhkan suatu operasi—untuk membocorkan informasi tentang kunci rahasia. Misalnya, jika perkalian dengan bit '1' dalam kunci membutuhkan waktu sedikit lebih lama daripada dengan bit '0', penyerang dapat merekonstruksi kunci dengan mengamati variasi waktu.

Operasi `BigInt` standar di JavaScript tidak memiliki waktu konstan. Waktu eksekusi mereka dapat bergantung pada nilai operand. Pustaka kriptografi profesional menggunakan algoritma yang sangat khusus untuk memastikan bahwa semua operasi yang melibatkan kunci privat membutuhkan waktu yang konstan, terlepas dari nilai kunci, sehingga mengurangi ancaman ini.

3. Pembuatan Angka Acak yang Aman

Keamanan sistem kriptografi apa pun dimulai dengan kualitas keacakannya. Kunci privat harus dibuat menggunakan generator angka pseudo-acak yang aman secara kriptografi (CSPRNG). Di lingkungan JavaScript, selalu gunakan API bawaan:

• Browser: crypto.getRandomValues()
• Node.js: crypto.randomBytes()

Jangan pernah menggunakan `Math.random()` untuk tujuan kriptografi, karena tidak dirancang untuk tidak dapat diprediksi.

4. Parameter Domain dan Validasi Kunci Publik

Saat menerima kunci publik dari sumber eksternal, penting untuk memvalidasinya. Penyerang dapat memberikan titik berbahaya yang sebenarnya tidak berada pada kurva eliptik yang ditentukan, yang dapat menyebabkan serangan yang mengungkapkan kunci privat Anda selama pertukaran kunci ECDH (misalnya, Serangan Kurva Tidak Valid). Pustaka terkemuka menangani validasi ini secara otomatis.

Kesimpulan

Kedatangan `BigInt` telah secara fundamental mengubah lanskap kriptografi dalam ekosistem JavaScript. Ini telah memindahkan ECC dari ranah pustaka kotak hitam buram ke sesuatu yang dapat diimplementasikan dan dipahami secara native, mendorong tingkat transparansi dan kemampuan baru.

Kami telah menjelajahi bagaimana fitur tunggal ini memungkinkan operasi kriptografi tingkat lanjut dan kuat yang menjadi pusat sistem aman modern:

• Pertukaran Kunci ECDH: Fondasi untuk membangun saluran komunikasi yang aman.
• Pemulihan Kunci Publik: Teknik peningkatan efisiensi yang sangat penting untuk sistem yang dapat diskalakan seperti blockchain.
• Tanda Tangan Schnorr: Skema tanda tangan generasi berikutnya yang menawarkan efisiensi, privasi, dan skalabilitas superior melalui agregasi.

Sebagai pengembang dan arsitek, memahami konsep-konsep canggih ini bukan lagi sekadar latihan akademis. Mereka sedang diterapkan dalam sistem global saat ini, dari peningkatan Taproot di Bitcoin hingga protokol perpesanan aman yang melindungi percakapan harian kita. Sementara implementasi akhir harus selalu diserahkan kepada pustaka yang diaudit dan ditinjau oleh para ahli, pemahaman mendalam tentang mekanik, dimungkinkan oleh alat seperti `BigInt`, memberdayakan kita untuk membangun aplikasi yang lebih aman, efisien, dan inovatif untuk audiens global.